module.exports=[
    {
        "name":"Map",
        "compatible":"IE9+",
        "tag":"键值对,快速查找",
        "note":"JavaScript的对象有个小问题，就是键必须是字符串。但实际上Number或者其他数据类型作为键也是非常合理的,es6引进了map",
        "code":`
        <div class='c_idea'>
        <h4>方法</h4>
        <dl>
            <dt>Map.prototype.clear()</dt>
            <dd>移除Map对象的所有键/值对 </dd>
        </dl>
        <dl>
            <dt>Map.prototype.delete(key)</dt>
            <dd>如果 Map 对象中存在该元素，则移除它并返回 true；否则如果该元素不存在则返回 false</dd>
        </dl>
        <dl>
            <dt>Map.prototype.entries()</dt>
            <dd>返回一个新的 Iterator 对象，它按插入顺序包含了Map对象中每个元素的 [key, value] 数组</dd>
        </dl>
        <dl>
            <dt>Map.prototype.forEach(callbackFn[, thisArg])</dt>
            <dd>按插入顺序，为 Map对象里的每一键值对调用一次callbackFn函数。如果为forEach提供了thisArg，它将在每次回调中作为this值</dd>
        </dl>
        <dl>
            <dt>Map.prototype.get(key)</dt>
            <dd>返回键对应的值，如果不存在，则返回undefined</dd>
        </dl>
        <dl>
            <dt>Map.prototype.has(key)
            </dt>
            <dd>返回一个布尔值，表示Map实例是否包含键对应的值</dd>
        </dl>
        <dl>
            <dt>Map.prototype.keys()</dt>
            <dd>返回一个新的 Iterator对象， 它按插入顺序包含了Map对象中每个元素的键</dd>
        </dl>
        <dl>
            <dt>Map.prototype.set(key, value)</dt>
            <dd>设置Map对象中键的值。返回该Map对象</dd>
        </dl>
        <dl>
            <dt>Map.prototype.values()</dt>
            <dd>返回一个新的Iterator对象，它按插入顺序包含了Map对象中每个元素的值</dd>
        </dl>
        <dl>
            <dt>Map.prototype[@@iterator]()</dt>
            <dd>返回一个新的Iterator对象，它按插入顺序包含了Map对象中每个元素的 [key, value] 数组</dd>
        </dl>
        </div>
        
        <pre><code>
        new Map([['Michael', 95], ['Bob', 75], ['Tracy', 85]]);//传参类型
        var m = new Map(); // 空Map
        m.set('Adam', 67); // 添加新的key-value
        m.set('Bob', 59);
        m.has('Adam'); // 是否存在key 'Adam': true
        m.get('Adam'); // 67
        m.delete('Adam'); // 删除key 'Adam'
        </code>
        </pre>`
    },{
        "name":"Set",
        "compatible":"IE9+",
        "tag":"去重",
        "note":"由于key不能重复，所以，在Set中，没有重复的key",
        "code":`
        <div class='c_idea'>
        <h4>方法</h4>
        <dl>
            <dt>Set.prototype.add(value)</dt>
            <dd>在Set对象尾部添加一个元素。返回该Set对象</dd>
        </dl>
        <dl>
            <dt>Set.prototype.clear()</dt>
            <dd>移除Set对象内的所有元素</dd>
        </dl>
        <dl>
            <dt>Set.prototype.delete(value)</dt>
            <dd>移除Set的中与这个值相等的元素，返回Set.prototype.has(value)在这个操作前会返回的值（即如果该元素存在，返回true，否则返回false）。Set.prototype.has(value)在此后会返回false</dd>
        </dl>
        <dl>
            <dt>Set.prototype.entries()
            </dt>
            <dd>返回一个新的迭代器对象，该对象包含Set对象中的按插入顺序排列的所有元素的值的[value, value]数组。为了使这个方法和Map对象保持相似， 每个值的键和值相等
            </dd>
        </dl>
        <dl>
            <dt>Set.prototype.forEach(callbackFn[, thisArg])
            </dt>
            <dd>按照插入顺序，为Set对象中的每一个值调用一次callBackFn。如果提供了thisArg参数，回调中的this会是这个参数
            </dd>
        </dl>
        <dl>
            <dt>Set.prototype.has(value)</dt>
            <dd>返回一个布尔值，表示该值在Set中存在与否。</dd>
        </dl>
        <dl>
            <dt>Set.prototype.keys()</dt>
            <dd>与values()方法相同，返回一个新的迭代器对象，该对象包含Set对象中的按插入顺序排列的所有元素的值</dd>
        </dl>
        <dl>
            <dt>Set.prototype.values()</dt>
            <dd>返回一个新的迭代器对象，该对象包含Set对象中的按插入顺序排列的所有元素的值</dd>
        </dl>
        <dl>
            <dt>Set.prototype[@@iterator]()</dt>
            <dd>返回一个新的迭代器对象，该对象包含Set对象中的按插入顺序排列的所有元素的值</dd>
        </dl>
        </div>
        <pre>
        <code>
        var s = new Set([1, 2, 3, 3, '3']);
        s; // Set {1, 2, 3, "3"}
        s.add(4);
        s; // Set {1, 2, 3, 4}
        s.add(4);
        s; // 仍然是 Set {1, 2, 3, 4}
        s.delete('3') //Set(3) {1, 2, 3}
        </code>
        </pre>`
    },{
        "name":"concat",
        "note":"concat() 方法用于连接两个或多个数组，不会改变现有的数组，而仅仅会返回被连接数组的一个副本",
        "code":`
        <pre>
        <code>
        arrayObject.concat(arrayX,arrayX,......,arrayX) //arrayX 必需 该参数可以是具体的值，也可以是数组对象。可以是任意多个。
        var a = [1,2,3];
        a.concat(4,5) //1 2 3 4 5
        </code></pre>`
    }, {
        "name":"join",
        "note":"join() 方法用于把数组通过指定的分隔符进行分隔的",
        "code":`
        <pre>
        <code>
        arrayObject.join(separator) //separator	分隔符
        var a = [1,2,3];
        a.join('') //123
        </code></pre>`
    }, {
        "name":"push",
        "note":"push() 方法可向数组的末尾添加一个或多个元素，并返回新的长度。",
        "code":`
        <pre>
        <code>
        arrayObject.push(newelement1,newelement2,....,newelementX)//newelement1必需。要添加到数组的第一个元素  其他可选
        var array1 = ['a', 'b', 'c'];
        array1.push('d') //a b c d
        </code></pre>`
    }, {
        "name":"pop",
        "note":"pop() 方法用于删除并返回数组的最后一个元素。如果数组已经为空，则 pop() 不改变数组，并返回 undefined 值。",
        "code":`
        <pre>
        <code>
        var array1 = ['a', 'b', 'c'];
        array1.pop() // a b
        </code></pre>`
    }, {
        "name":"shift",
        "note":"shift() 方法用于把数组的第一个元素从其中删除，并返回第一个元素的值。如果数组是空的，那么 shift() 方法将不进行任何操作，返回 undefined 值。 ",
        "code":`
        <pre>
        <code>
        var array1 = ['a', 'b', 'c'];
        array1.shift() //b c
        </code></pre>`
    }, {
        "name":"unshift",
        "note":"unshift() 方法可向数组的开头添加一个或更多元素，并返回新的长度。",
        "code":`
        <pre>
        <code>
        arrayObject.unshift(newelement1,newelement2,....,newelementX) //newelement1必填 其他选填
        var array1 = ['a', 'b', 'c'];
        array1.unshift('0') //0 a b c
        </code></pre>`
    }, {
        "name":"slice",
        "note":"slice() 方法可从已有的数组中返回选定的元素。(含头不含尾)",
        "code":`
        <pre>
        <code>
        arrayObject.slice(start,end)
        //start 必需。规定从何处开始选取。如果是负数，那么它规定从数组尾部开始算起的位置。
                也就是说，-1 指最后一个元素，-2 指倒数第二个元素，以此类推。
        //end   可选。规定从何处结束选取。该参数是数组片断结束处的数组下标。
                如果没有指定该参数，那么切分的数组包含从 start 到数组结束的所有元素。
                如果这个参数是负数，那么它规定的是从数组尾部开始算起的元素。
        var array1 = ['a', 'b', 'c','d'];
        array1.slice(1) // b c d
        array1.slice(1,3);//b c     1的下标是b 三的下标是d  1-3中间的为 b c
        </code></pre>`
    }, {
        "name":"splice",
        "note":"splice() 方法向/从数组中添加/删除项目，然后返回被删除的项目。该方法会改变原始数组!!!",
        "code":`
        <pre>
        <code>
        arrayObject.splice(index,howmany,item1,.....,itemX)
        //index必需。整数，规定添加/删除项目的位置，使用负数可从数组结尾处规定位置。
        //howmany必需。要删除的项目数量。如果设置为 0，则不会删除项目。
        //item1, ..., itemX	可选。向数组添加的新项目。
        var array1 = ['a', 'b', 'c','d','e','f'];
        array1.splice(2,3) //c d e
        console.log(array1);//a b f
        </code></pre>`
    }, {
        "name":"reverse",
        "note":"reverse() 方法用于颠倒数组中元素的顺序。会改变原数组!!!",
        "code":`
        <pre>
        <code>
        var array1 = ['a', 'b', 'c'];
        array1.reverse() // c b a
        </code></pre>`
    }, {
        "name":"reduce",
        "compatible":"IE9+",
        "note":"reduce() 方法接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值。",
        "code":`
        <pre>
        <code>
        array.reduce(function(total, currentValue, currentIndex, arr), initialValue)
        //total	必需。初始值, 或者计算结束后的返回值。
        //currentValue 必需。当前元素
        //currentIndex	 可选。当前元素的索引
        //arr    可选。当前元素所属的数组对象。
        var numbers = [15.5, 2.3, 1.1, 4.7];
        function getSum(total, num) {
            //total index  Math.round(num)//四舍五入value
            return total + Math.round(num); //16+2+1+5
        }
        numbers.reduce(getSum, 0)//24
        </code></pre>`
    }, {
        "name":"indexOf",
        "note":"indexOf() 方法可返回数组中某个指定的元素位置。 ",
        "code":`<pre>
        <code>
        array.indexOf(item,start)
        //item  必须。查找的元素。
        //start 可选的整数参数。规定在数组中开始检索的位置。它的合法取值是 0 到 stringObject.length - 1。
                如省略该参数，则将从字符串的首字符开始检索。
        var array1 = ['a', 'b', 'c'];
        array1.indexOf('a') //0
        /*从4的位置开始找Apple 只有最后一个匹配到*/
        var fruits=["Banana","Orange","Apple","Mango","Banana","Orange","Apple"];
        var a = fruits.indexOf("Apple",4);//6
        </code></pre>`
    }, {
        "name":"lastIndexOf",
        "note":"lastIndexOf() 方法可返回一个指定的元素在数组中最后出现的位置，从该字符串的后面向前查找。",
        "code":`<pre>         
        <code>
        array.lastIndexOf(item,start)
        //item  必须。查找的元素。
        //start 可选的整数参数。规定在数组中开始检索的位置。它的合法取值是 0 到 stringObject.length - 1。
                如省略该参数，则将从字符串的最后一个字符处开始检索。
        var array1 = ['a', 'b', 'c'];
        array1.lastIndexOf('a') //0
        /*从4的位置开始找Apple 只有下标为2匹配到*/
        var fruits=["Banana","Orange","Apple","Mango","Banana","Orange","Apple"];
        var a = fruits.lastIndexOf("Apple",4);//2
        </code></pre>`
    }, {
        "name":"forEach",
        "compatible":"IE9+",
        "note":"forEach() 方法用于调用数组的每个元素，并将元素传递给回调函数。",
        "code":`
        <pre>         
        <code>
        array.forEach(function(currentValue, index, arr), thisValue)
        //currentValue  必需。当前元素
        //index         可选。当前元素下标
        //arr           可选。当前元素所属的数组对象。
        //thisValue     可选。对象作为该执行回调时使用，传递给函数，用作 "this" 的值。
                        如果省略了 thisValue，或者传入 null、undefined，那么回调函数的 this 为全局对象。
        var array1 = ['a', 'b', 'c'];
        array1.forEach(function(element) {
        console.log(element);//a b c
        });
        array1.forEach(function(element) {
            console.log(this);//this为12  如果thisValue为12为null/undefined则this为window
        },12);
        </code></pre>`
    }, {
        "name":"map",
        "compatible":"IE9+",
        "note":"map() 方法返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值。",
        "code":`
        <pre>         
        <code>
        array.map(function(currentValue,index,arr), thisValue)
        //currentValue  必需。当前元素
        //index         可选。当前元素下标
        //arr           可选。当前元素所属的数组对象。
        //thisValue     可选。对象作为该执行回调时使用，传递给函数，用作 "this" 的值。
                        如果省略了 thisValue，或者传入 null、undefined，那么回调函数的 this 为全局对象。
        const users=items.map(item => ({
            url: item.html_url,      
            img: item.avatar_url   
            })
        );
        var array1 = ['a', 'b', 'c'];
        array1.map(function(element) {
            return element+=this//a12 b12 c12
        },12);
        </code></pre>`
    }, {
        "name":"every",
        "compatible":"IE9+",
        "note":"every() 不会改变原始数组,用于检测数组所有元素是否都符合指定条件,有一个元素不满足，则整个表达式返回 false ，且剩余的元素不会再进行检测,",
        "code":`
        <pre>
        <code>
        array.every(function(currentValue,index,arr), thisValue)
        // 参数类同forEach/map
        var ages = [32, 33, 12, 40];
        function checkAdult(age) {
            return age >= 18;//false
        }
        ages.every(checkAdult)
        </code></pre>`
    },{
        "name":"some",
        "compatible":"IE9+",
        "note":" some() 不会改变原始数组。some() 方法用于检测数组中的元素是否满足指定条件（函数提供）。如果有一个元素满足条件，则表达式返回true , 剩余的元素不会再执行检测",
        "code":`<pre>
        <code>
        //array.some(function(currentValue,index,arr),thisValue)
        // 参数类同forEach/map
        var ages = [32, 33, 12, 40];
        function checkAdult(age) {
            return age >= 18;//true
        }
        ages.some(checkAdult)
        </code></pre>`
    },{
        "name":"filter",
        "compatible":"IE9+",
        "note":"filter() 不会改变原始数组。filter() 方法创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素。",
        "code":`<pre>
        <code>
        array.filter(function(currentValue,index,arr), thisValue)
        // 参数类同forEach/map
        var array1 = [12,1,3,4];
        function checkAdult(num) {
            return num >= 2;
        }
        array1.filter(checkAdult) //12 3 4
        </code></pre>`
    }, {
        "name":"find",
        "compatible":"IE12+",
        "note":"find() 方法返回通过测试（函数内判断）的数组的第一个元素的值。 ",
        "code":`<pre>
        <code>
        array.find(function(currentValue, index, arr),thisValue)
        // 参数类同forEach/map
        var array1 = [12,1,3,4];
        function checkAdult(num) {
            return num >= 2;
        }
        array1.find(checkAdult) //12
        </code></pre>`
    },{
        "name":"findIndex",
        "compatible":"IE12+",
        "note":"findIndex() 方法返回传入一个测试条件（函数）符合条件的数组第一个元素位置。",
        "code":`<pre>
        <code>
        array.findIndex(function(currentValue, index, arr), thisValue)
        // 参数类同forEach/map
        function checkAdult(num) {
            return num >= 2;
        }
        array1.findIndex(checkAdult) //0
        </code></pre>`
    },{
        "name":"fill",
        "compatible":"IE12+",
        "note":"fill() 方法用于将一个固定值替换数组的元素。",
        "code":`
        <pre><code>
        array.fill(value, start, end)
        //value 必需。填充的值。
        //start 可选。开始填充位置。
        //end   可选。停止填充位置 (默认为 array.length)
        var fruits = ["Banana", "Orange", "Apple", "Mango",'cliss'];
        //4-2=2 从2位置填充两次"Runoob" 
        fruits.fill("Runoob", 2, 4); //Banana,Orange,Runoob,Runoob,cliss
        </code></pre>`
    },{
        "name":"copyWithin",
        "compatible":"IE12+",
        "note":"copyWithin() 方法用于从数组的指定位置拷贝元素到数组的另一个指定位置中。",
        "code":`<pre><code>
        array.copyWithin(target, start, end)
        // target	必需。复制到指定目标索引位置。
        // start	可选。元素复制的起始位置。
        // end	    可选。停止复制的索引位置 (默认为 array.length)。如果为负值，表示倒数
        var fruits = ["Banana", "Orange", "Apple", "Mango"];
        //复制下标从0-2(不含2)的东西,在2的位置开始替换
        fruits.copyWithin(2, 0); //Banana,Orange,Banana,Orange
        var fruits = ["Banana", "Orange", "Apple", "Mango", "Kiwi", "Papaya"];
        //复制下标从0-2的东西,在2的位置开始替换,只替换两个下标
        fruits.copyWithin(2, 0, 2);//Banana,Orange,Banana,Orange,Kiwi,Papaya
        fruits.copyWithin(2, 0, 3);//Banana,Orange,Banana,Orange,Banana,Papaya
        </code></pre>`
    },{
        "name":"entries",
        "compatible":"IE12+",
        "note":"entries() 方法返回一个数组的迭代对象，该对象包含数组的键值对 (key/value)。",
        "code":`<pre><code>
        array.entries()
        var array=['a', 'b', 'c']    
        let c= array.entries()  
        c.next().value //[0,'a'];
        c.next().value //[1,'b'];
        c.next().value //[2,'c'];
        c.next() //{value:undefined,done:true}

        for(let [key, value] of arr.entries()){console.log([key,value])} //[0,'a'],[1,'b'],[2,'c']
        </code></pre>`
    },{
        "name":"keys",
        "compatible":"IE12+",
        "note":"keys() 方法用于从数组创建一个包含数组键的可迭代对象。如果对象是数组返回 true，否则返回 false。",
        "code":`<pre><code>
        array.keys()
        var arr=['a', 'b', 'c']
        let c= arr.keys()  
        c.next() //{value:0,done:false}
        c.next() //{value:0,done:false}
        c.next() //{value:0,done:false}
        c.next() //{value:undefined,done:true}

        for(let key of arr.keys()){console.log(key)} //0,1,2    
        </code></pre>`
    },{
        "name":"includes",
        "compatible":"IE14+",
        "note":"判断数组是否包含某项，返回true/false",
        "code":`<pre><code>
        arr.includes(searchElement, fromIndex)
        //searchElement 必须。需要查找的元素值。
        //formIndex    可选。从该索引处开始查找 searchElement。如果为负值，则按升序从 array.length + fromIndex 的索引开始搜索。默认为 0。
        [1, 2, 3, 4, 5].includes(4)    //true
        [1, 2, 3, 4, NaN].includes(NaN)    //true
        //如果fromIndex 大于等于数组长度 ，则返回 false 。该数组不会被搜索:
        var arr = ['a', 'b', 'c'];
        arr.includes('c', 3);   //false
        arr.includes('c', 100); // false
        //如果 fromIndex 为负值，计算出的索引将作为开始搜索searchElement的位置。如果计算出的索引小于 0，则整个数组都会被搜索。
        arr.includes('a', -100); // true
        </code></pre>`
    }
]
